home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / game / shoot / ADoom_src_1_1.lha / ADoom_src / r_things.c < prev    next >
C/C++ Source or Header  |  1998-02-19  |  21KB  |  1,022 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. //    Refresh of things, i.e. objects represented by sprites.
  21. //
  22. //-----------------------------------------------------------------------------
  23.  
  24.  
  25. static const char
  26. rcsid[] = "$Id: r_things.c,v 1.5 1997/02/03 16:47:56 b1 Exp $";
  27.  
  28.  
  29. #include <stdio.h>
  30. #include <stdlib.h>
  31.  
  32.  
  33. #include "doomdef.h"
  34. #include "m_swap.h"
  35.  
  36. #include "i_system.h"
  37. #include "z_zone.h"
  38. #include "w_wad.h"
  39.  
  40. #include "r_local.h"
  41.  
  42. #include "doomstat.h"
  43.  
  44.  
  45.  
  46. #define MINZ                (FRACUNIT*4)
  47. //#define BASEYCENTER            100
  48. #define BASEYCENTER ((weirdaspect==1)?100:75)
  49.  
  50. //void R_DrawColumn (void);
  51. //void R_DrawFuzzColumn (void);
  52.  
  53.  
  54.  
  55. typedef struct
  56. {
  57.     int        x1;
  58.     int        x2;
  59.     
  60.     int        column;
  61.     int        topclip;
  62.     int        bottomclip;
  63.  
  64. } maskdraw_t;
  65.  
  66.  
  67.  
  68. //
  69. // Sprite rotation 0 is facing the viewer,
  70. //  rotation 1 is one angle turn CLOCKWISE around the axis.
  71. // This is not the same as the angle,
  72. //  which increases counter clockwise (protractor).
  73. // There was a lot of stuff grabbed wrong, so I changed it...
  74. //
  75. fixed_t        pspritescale;
  76. fixed_t        pspriteiscale;
  77. //fixed_t        pspritescale2;
  78. fixed_t        pspriteiscale2;
  79.  
  80. lighttable_t**    spritelights;
  81.  
  82. // constant arrays
  83. //  used for psprite clipping and initializing clipping
  84. //short        negonearray[SCREENWIDTH];
  85. //short        screenheightarray[SCREENWIDTH];
  86. short        *negonearray;
  87. short        *screenheightarray;
  88.  
  89.  
  90. //
  91. // INITIALIZATION FUNCTIONS
  92. //
  93.  
  94. // variables used to look up
  95. //  and range check thing_t sprites patches
  96. spritedef_t*    sprites;
  97. int        numsprites;
  98.  
  99. FAR spriteframe_t    sprtemp[29];
  100. int        maxframe;
  101. char*        spritename;
  102.  
  103.  
  104.  
  105.  
  106. //
  107. // R_InstallSpriteLump
  108. // Local function for R_InitSprites.
  109. //
  110. void
  111. R_InstallSpriteLump
  112. ( int        lump,
  113.   unsigned    frame,
  114.   unsigned    rotation,
  115.   boolean    flipped )
  116. {
  117.     int        r;
  118.     
  119.     if (frame >= 29 || rotation > 8)
  120.     I_Error("R_InstallSpriteLump: "
  121.         "Bad frame characters in lump %i", lump);
  122.     
  123.     if ((int)frame > maxframe)
  124.     maxframe = frame;
  125.         
  126.     if (rotation == 0)
  127.     {
  128.     // the lump should be used for all rotations
  129.     if (sprtemp[frame].rotate == false)
  130.         I_Error ("R_InitSprites: Sprite %s frame %c has "
  131.              "multip rot=0 lump", spritename, 'A'+frame);
  132.  
  133.     if (sprtemp[frame].rotate == true)
  134.         I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  135.              "and a rot=0 lump", spritename, 'A'+frame);
  136.             
  137.     sprtemp[frame].rotate = false;
  138.     for (r=0 ; r<8 ; r++)
  139.     {
  140.         sprtemp[frame].lump[r] = lump - firstspritelump;
  141.         sprtemp[frame].flip[r] = (byte)flipped;
  142.     }
  143.     return;
  144.     }
  145.     
  146.     // the lump is only used for one rotation
  147.     if (sprtemp[frame].rotate == false)
  148.     I_Error ("R_InitSprites: Sprite %s frame %c has rotations "
  149.          "and a rot=0 lump", spritename, 'A'+frame);
  150.         
  151.     sprtemp[frame].rotate = true;
  152.  
  153.     // make 0 based
  154.     rotation--;        
  155.     if (sprtemp[frame].lump[rotation] != -1)
  156.     I_Error ("R_InitSprites: Sprite %s : %c : %c "
  157.          "has two lumps mapped to it",
  158.          spritename, 'A'+frame, '1'+rotation);
  159.         
  160.     sprtemp[frame].lump[rotation] = lump - firstspritelump;
  161.     sprtemp[frame].flip[rotation] = (byte)flipped;
  162. }
  163.  
  164.  
  165.  
  166.  
  167. //
  168. // R_InitSpriteDefs
  169. // Pass a null terminated list of sprite names
  170. //  (4 chars exactly) to be used.
  171. // Builds the sprite rotation matrixes to account
  172. //  for horizontally flipped sprites.
  173. // Will report an error if the lumps are inconsistant. 
  174. // Only called at startup.
  175. //
  176. // Sprite lump names are 4 characters for the actor,
  177. //  a letter for the frame, and a number for the rotation.
  178. // A sprite that is flippable will have an additional
  179. //  letter/number appended.
  180. // The rotation character can be 0 to signify no rotations.
  181. //
  182. void R_InitSpriteDefs (char** namelist) 
  183. { 
  184.     char**    check;
  185.     int        i;
  186.     int        l;
  187.     int        intname;
  188.     int        frame;
  189.     int        rotation;
  190.     int        start;
  191.     int        end;
  192.     int        patched;
  193.         
  194.     // count the number of sprite names
  195.     check = namelist;
  196.     while (*check != NULL)
  197.     check++;
  198.  
  199.     numsprites = check-namelist;
  200.     
  201.     if (!numsprites)
  202.     return;
  203.         
  204.     sprites = Z_Malloc(numsprites *sizeof(*sprites), PU_STATIC, NULL);
  205.     
  206.     start = firstspritelump-1;
  207.     end = lastspritelump+1;
  208.     
  209.     // scan all the lump names for each of the names,
  210.     //  noting the highest frame letter.
  211.     // Just compare 4 characters as ints
  212.     for (i=0 ; i<numsprites ; i++)
  213.     {
  214.     spritename = namelist[i];
  215.     memset (sprtemp,-1, sizeof(sprtemp));
  216.         
  217.     maxframe = -1;
  218.     intname = *(int *)namelist[i];
  219.     
  220.     // scan the lumps,
  221.     //  filling in the frames for whatever is found
  222.     for (l=start+1 ; l<end ; l++)
  223.     {
  224.         if (*(int *)lumpinfo[l].name == intname)
  225.         {
  226.         frame = lumpinfo[l].name[4] - 'A';
  227.         rotation = lumpinfo[l].name[5] - '0';
  228.  
  229.         if (modifiedgame)
  230.             patched = W_GetNumForName (lumpinfo[l].name);
  231.         else
  232.             patched = l;
  233.  
  234.         R_InstallSpriteLump (patched, frame, rotation, false);
  235.  
  236.         if (lumpinfo[l].name[6])
  237.         {
  238.             frame = lumpinfo[l].name[6] - 'A';
  239.             rotation = lumpinfo[l].name[7] - '0';
  240.             R_InstallSpriteLump (l, frame, rotation, true);
  241.         }
  242.         }
  243.     }
  244.     
  245.     // check the frames that were found for completeness
  246.     if (maxframe == -1)
  247.     {
  248.         sprites[i].numframes = 0;
  249.         continue;
  250.     }
  251.         
  252.     maxframe++;
  253.     
  254.     for (frame = 0 ; frame < maxframe ; frame++)
  255.     {
  256.         switch ((int)sprtemp[frame].rotate)
  257.         {
  258.           case -1:
  259.         // no rotations were found for that frame at all
  260.         I_Error ("R_InitSprites: No patches found "
  261.              "for %s frame %c", namelist[i], frame+'A');
  262.         break;
  263.         
  264.           case 0:
  265.         // only the first rotation is needed
  266.         break;
  267.             
  268.           case 1:
  269.         // must have all 8 frames
  270.         for (rotation=0 ; rotation<8 ; rotation++)
  271.             if (sprtemp[frame].lump[rotation] == -1)
  272.             I_Error ("R_InitSprites: Sprite %s frame %c "
  273.                  "is missing rotations",
  274.                  namelist[i], frame+'A');
  275.         break;
  276.         }
  277.     }
  278.     
  279.     // allocate space for the frames present and copy sprtemp to it
  280.     sprites[i].numframes = maxframe;
  281.     sprites[i].spriteframes = 
  282.         Z_Malloc (maxframe * sizeof(spriteframe_t), PU_STATIC, NULL);
  283.     memcpy (sprites[i].spriteframes, sprtemp, maxframe*sizeof(spriteframe_t));
  284.     }
  285.  
  286. }
  287.  
  288.  
  289.  
  290.  
  291. //
  292. // GAME FUNCTIONS
  293. //
  294. FAR vissprite_t    vissprites[MAXVISSPRITES];
  295. vissprite_t*    vissprite_p;
  296. int        newvissprite;
  297.  
  298.  
  299.  
  300. //
  301. // R_InitSprites
  302. // Called at program start.
  303. //
  304. void R_InitSprites (char** namelist)
  305. {
  306.     int        i;
  307.     
  308.     for (i=0 ; i<SCREENWIDTH ; i++)
  309.     {
  310.     negonearray[i] = -1;
  311.     }
  312.     
  313.     R_InitSpriteDefs (namelist);
  314. }
  315.  
  316.  
  317.  
  318. //
  319. // R_ClearSprites
  320. // Called at frame start.
  321. //
  322. void R_ClearSprites (void)
  323. {
  324.     vissprite_p = vissprites;
  325. }
  326.  
  327.  
  328. //
  329. // R_NewVisSprite
  330. //
  331. vissprite_t    overflowsprite;
  332.  
  333. vissprite_t* R_NewVisSprite (void)
  334. {
  335.     if (vissprite_p == &vissprites[MAXVISSPRITES])
  336.     return &overflowsprite;
  337.     
  338.     vissprite_p++;
  339.     return vissprite_p-1;
  340. }
  341.  
  342.  
  343.  
  344. //
  345. // R_DrawMaskedColumn
  346. // Used for sprites and masked mid textures.
  347. // Masked means: partly transparent, i.e. stored
  348. //  in posts/runs of opaque pixels.
  349. //
  350. short*        mfloorclip;
  351. short*        mceilingclip;
  352.  
  353. fixed_t        spryscale;
  354. fixed_t        sprtopscreen;
  355.  
  356. #ifndef AMIGA
  357. void R_DrawMaskedColumn (column_t* column)
  358. {
  359.     int        topscreen;
  360.     int     bottomscreen;
  361.     fixed_t    basetexturemid;
  362.     
  363.     basetexturemid = dc_texturemid;
  364.     
  365.     for ( ; column->topdelta != 0xff ; ) 
  366.     {
  367.     // calculate unclipped screen coordinates
  368.     //  for post
  369.     topscreen = sprtopscreen + spryscale*column->topdelta;
  370.     bottomscreen = topscreen + spryscale*column->length;
  371.  
  372.     dc_yl = (topscreen+FRACUNIT-1)>>FRACBITS;
  373.     dc_yh = (bottomscreen-1)>>FRACBITS;
  374.         
  375.     if (dc_yh >= mfloorclip[dc_x])
  376.         dc_yh = mfloorclip[dc_x]-1;
  377.     if (dc_yl <= mceilingclip[dc_x])
  378.         dc_yl = mceilingclip[dc_x]+1;
  379.  
  380.     if (dc_yl <= dc_yh)
  381.     {
  382.         dc_source = (byte *)column + 3;
  383.         dc_texturemid = basetexturemid - (column->topdelta<<FRACBITS);
  384.         // dc_source = (byte *)col